home *** CD-ROM | disk | FTP | other *** search
/ Saar AMOK 2 / Saar AMOK II - Oktober 1994 (1994)(Kreativ Marketing)(DE)[!][I-7598].iso / disks / 651_700 / 652 / xpkdisk / source.lha / prefsmain.c < prev    next >
C/C++ Source or Header  |  1993-11-08  |  13KB  |  646 lines
  1. /*-
  2.  * PREFSMAIN.C
  3.  *
  4.  * The main file of the xpkdisk preferences utility.
  5.  *
  6.  * $Id: prefsmain.c,v 1.3 1993/11/08 13:11:15 Rhialto Rel $
  7.  * $Log: prefsmain.c,v $
  8.  * Revision 1.3  1993/11/08  13:11:15  Rhialto
  9.  * Add RCS tags.
  10.  *
  11.  *
  12.  * This code is (C) Copyright 1992,1993 by Olaf Seibert. All rights reserved.
  13.  * May not be used or copied without a licence.
  14. -*/
  15.  
  16. #define INTUI_V36_NAMES_ONLY
  17.  
  18. #include "xpkdisk.h"
  19.  
  20. #ifndef LIBRARIES_GADTOOLS_H
  21. #include <libraries/gadtools.h>
  22. #endif
  23. #ifndef LIBRARIES_ASL_H
  24. #include <libraries/asl.h>
  25. #endif
  26. #ifndef INTUITION_GADGETCLASS_H
  27. #include <intuition/gadgetclass.h>
  28. #endif
  29. #ifndef DOS_DOS_H
  30. #include <dos/dos.h>
  31. #endif
  32. #ifndef DOS_DOSEXTENS_H
  33. #include <dos/dosextens.h>
  34. #endif
  35. #ifndef DOS_FILEHANDLER_H
  36. #include <dos/filehandler.h>
  37. #endif
  38. #ifndef EXEC_MEMORY_H
  39. #include <exec/memory.h>
  40. #endif
  41.  
  42. #include <stdio.h>
  43. #include <stdlib.h>
  44. #include <string.h>
  45. #include <stdarg.h>
  46.  
  47. #include <clib/exec_protos.h>
  48. #include <clib/intuition_protos.h>
  49. #include <clib/gadtools_protos.h>
  50. #include <clib/asl_protos.h>
  51. #include <clib/alib_protos.h>
  52. #include <clib/dos_protos.h>
  53.  
  54. #include "prefswindow.h"
  55.  
  56. struct Library *GadToolsBase;
  57. struct IntuitionBase *IntuitionBase;
  58. struct Library *AslBase;
  59. extern struct ExecBase *SysBase;
  60.  
  61. struct Settings {
  62.     short        MaxCache;
  63.     ushort        CacheFlags;
  64.     char        CacheCMDUPDATE;
  65.     char        CacheDELAY;
  66.     char        CacheSAFE;
  67.     char        Licensed;
  68.     short        CacheTimeout;
  69.     char        XPKPackMethod[10];     /* "XXXX.100" */
  70. };
  71.  
  72. const char    DevName[] = "xpkdisk.device";
  73. long        DevUnit;
  74. struct XpkDiskUnit *Unit;
  75. struct MsgPort *ReplyPort;
  76. struct IOExtTD *IOReq;
  77. struct FileRequest *FileRequest;
  78. struct Settings Defaults = {
  79.     MAX_CACHE,
  80.     CACHE_FLAGS,
  81.     (CACHE_FLAGS & CACHEF_CMDUPDATE) != 0,
  82.     (CACHE_FLAGS & CACHEF_DELAY) != 0,
  83.     (CACHE_FLAGS & CACHEF_SAFEWRITE) != 0,
  84.     1,
  85.     CACHE_TIMEOUT,
  86.     PACKING_METHOD
  87. };
  88. struct Settings Settings;
  89. struct Settings Initial;
  90.  
  91. const char    RCSId[] = "\0$VER: xpkdisk.device Prefs $Revision: 1.3 $ $Date: 1993/11/08 13:11:15 $, by Olaf Seibert";
  92. const char    OkString[] = "Ok";
  93. const char    AbortString[] = "Abort";
  94. const char    PanicString[] = "Panic!";
  95. const char    Env[] = CONFIGFILE;
  96. const char    EnvArc[] = CONFIGFILE_ARC;
  97.  
  98. void        Show(void);
  99. void        Hide(void);
  100. void        SetGadgetAttr(int id, ULONG tag, ULONG value);
  101. int        Save(char *filename, int notify);
  102. void        SelectUnit(int unit);
  103. void        DeselectUnit(void);
  104. extern int    ReadConfig(UNIT *unit, char *buf, int sz);
  105.  
  106. #define DONE_DONE   1
  107.  
  108. void
  109. GT_SetGadgetAttrs(struct Gadget *gad, struct Window *win,
  110.           struct Requester *req, Tag tag1, ... )
  111. {
  112.     GT_SetGadgetAttrsA(gad, win, req, (void *)&tag1);
  113. }
  114.  
  115. APTR
  116. GetVisualInfo(struct Screen *screen, Tag tag1, ... )
  117. {
  118.     return GetVisualInfoA(screen, (void *)&tag1);
  119. }
  120.  
  121. void
  122. DrawBevelBox(struct RastPort *rport, long left, long top, long width,
  123.          long height, Tag tag1, ... )
  124. {
  125.     DrawBevelBoxA(rport, left, top, width, height, (void *)&tag1);
  126. }
  127.  
  128. struct Menu *
  129. CreateMenus(struct NewMenu *newmenu, Tag tag1, ... )
  130. {
  131.     return CreateMenusA(newmenu, (void *)&tag1);
  132. }
  133.  
  134. BOOL
  135. LayoutMenus(struct Menu *firstmenu, APTR vi, Tag tag1, ... )
  136. {
  137.     return LayoutMenusA(firstmenu, vi, (void *)&tag1);
  138. }
  139.  
  140. long min(long a, long b)
  141. {
  142.     return a < b? a : b;
  143. }
  144.  
  145. void
  146. Die(void)
  147. {
  148.     Hide();
  149.     DeselectUnit();
  150.  
  151.     if (IOReq) {
  152.     DeleteExtIO((struct IORequest *)IOReq);
  153.     IOReq = NULL;
  154.     }
  155.  
  156.     if (ReplyPort) {
  157.     DeletePort(ReplyPort);
  158.     ReplyPort = NULL;
  159.     }
  160.  
  161.     if (AslBase) {
  162.     if (FileRequest) {
  163.         FreeAslRequest(FileRequest);
  164.         FileRequest = NULL;
  165.     }
  166.  
  167.     CloseLibrary(AslBase);
  168.     IntuitionBase = NULL;
  169.     }
  170.     if (IntuitionBase) {
  171.     CloseLibrary(IntuitionBase);
  172.     IntuitionBase = NULL;
  173.     }
  174.     if (GadToolsBase) {
  175.     CloseLibrary(GadToolsBase);
  176.     GadToolsBase = NULL;
  177.     }
  178.     exit(0);
  179. }
  180.  
  181. void
  182. OpenAll(int argc, char **argv)
  183. {
  184.     extern struct Library *DOSBase;
  185.  
  186.     if (DOSBase->lib_Version < 37) {
  187.     puts("Sorry, requires at least V37...");
  188.     Die();
  189.     }
  190.     GadToolsBase = OpenLibrary("gadtools.library", 37L);
  191.     if (!GadToolsBase)
  192.     Die();
  193.  
  194.     IntuitionBase = OpenLibrary("intuition.library", 37L);
  195.     if (!IntuitionBase)
  196.     Die();
  197.  
  198.     AslBase = OpenLibrary("asl.library", 37L);
  199.     if (!AslBase)
  200.     Die();
  201.  
  202.     ReplyPort = CreatePort(NULL, 0);
  203.     if (!ReplyPort)
  204.     Die();
  205.  
  206.     IOReq = CreateExtIO(ReplyPort, sizeof(*IOReq));
  207.     if (!IOReq)
  208.     Die();
  209.  
  210.     Show();
  211. }
  212.  
  213. void
  214. Show(void)
  215. {
  216.     if (PrefsWnd) {
  217.     WindowToFront(PrefsWnd);
  218.     return;         /* already open */
  219.     }
  220.  
  221.     if (SetupScreen())
  222.     Die();
  223.  
  224.     if (OpenPrefsWindow())
  225.     Die();
  226.  
  227.     SelectUnit(DevUnit);
  228. }
  229.  
  230. void
  231. Hide(void)
  232. {
  233.     if (PrefsWnd) {
  234.     struct IntuiMessage *msg;
  235.  
  236.     while (msg = GT_GetIMsg(PrefsWnd->UserPort)) {
  237.         GT_ReplyIMsg(msg);
  238.     }
  239.     }
  240.  
  241.     ClosePrefsWindow();
  242.     CloseDownScreen();
  243. }
  244.  
  245. void
  246. SetGadgetAttr(int id, ULONG tag, ULONG value)
  247. {
  248.     GT_SetGadgetAttrs(PrefsGadgets[id], PrefsWnd, NULL,
  249.               tag, value,
  250.               TAG_END);
  251. }
  252.  
  253. int
  254. Confirm(char *fmt, char *buttons, ...)
  255. {
  256.     static struct EasyStruct er0 = {
  257.     sizeof er0, 0, "xpkdisk Prefs",
  258.     NULL,
  259.     NULL,
  260.     };
  261.     struct EasyStruct er;
  262.     va_list        va;
  263.  
  264.     er = er0;
  265.     er.es_TextFormat = fmt;
  266.     er.es_GadgetFormat = buttons;
  267.     va_start(va, buttons);
  268.       return EasyRequestArgs(PrefsWnd, &er, NULL, va);
  269.     va_end(va)          /* produces error if it doesn't expand to empty */
  270. }
  271.  
  272. void
  273. DeselectUnit(void)
  274. {
  275.     if (IOReq->iotd_Req.io_Unit != NULL &&
  276.     IOReq->iotd_Req.io_Unit != (void *)-1)
  277.     CloseDevice((struct IORequest *)IOReq);
  278.  
  279.     IOReq->iotd_Req.io_Unit = NULL;
  280.     Unit = NULL;
  281. }
  282.  
  283. void
  284. UpdateGadgets(void)
  285. {
  286.     SetGadgetAttr(GDX_UNIT, GTSL_Level, DevUnit);
  287.     SetGadgetAttr(GDX_MAXCACHE, GTSL_Level, Settings.MaxCache);
  288.     SetGadgetAttr(GDX_CMDUPDATE, GTCB_Checked, Settings.CacheCMDUPDATE);
  289.     SetGadgetAttr(GDX_DELAY, GTCB_Checked, Settings.CacheDELAY);
  290.     SetGadgetAttr(GDX_SAFE, GTCB_Checked, Settings.CacheSAFE);
  291.     SetGadgetAttr(GDX_TIME, GTSL_Level, Settings.CacheTimeout);
  292.     SetGadgetAttr(GDX_METHOD, GTST_String, (ULONG)Settings.XPKPackMethod);
  293. }
  294.  
  295. void
  296. ConfigFromUnit(UNIT *unit)
  297. {
  298.     Settings.MaxCache = unit->xu_MaxCache;
  299.     Settings.CacheFlags = unit->xu_CacheFlags;
  300.     Settings.CacheCMDUPDATE = (Settings.CacheFlags & CACHEF_CMDUPDATE) != 0;
  301.     Settings.CacheDELAY     = (Settings.CacheFlags & CACHEF_DELAY) != 0;
  302.     Settings.CacheSAFE        = (Settings.CacheFlags & CACHEF_SAFEWRITE) != 0;
  303.     Settings.Licensed        = (Settings.CacheFlags & CACHEF_LICENSED) != 0;
  304.     Settings.CacheTimeout = unit->xu_CacheTimeout;
  305.     strcpy(Settings.XPKPackMethod, unit->xu_XPKPackMethod);
  306.  
  307.     UpdateGadgets();
  308. }
  309.  
  310. void
  311. SelectUnit(int unit)
  312. {
  313.     if (Unit && unit == DevUnit)
  314.     return;
  315.  
  316.     DeselectUnit();
  317.  
  318.     DevUnit = unit;
  319.     if (OpenDevice(DevName, unit, (struct IORequest *)IOReq, 0) != 0) {
  320.     DeselectUnit();
  321.     Confirm("Cannot open unit %ld", OkString, unit);
  322.     return;
  323.     }
  324.  
  325.     /* Make sure unit has initialised itself */
  326.     IOReq->iotd_Req.io_Command = CMD_UPDATE;
  327.     DoIO((struct IORequest *)IOReq);
  328.  
  329.     Unit = IOReq->iotd_Req.io_Unit;
  330.     ConfigFromUnit(Unit);
  331.     Initial = Settings;
  332. }
  333.  
  334. int
  335. Save(char *filename, int notify)
  336. {
  337.     char        buffer[160];
  338.     BPTR        fh;
  339.  
  340.     sprintf(buffer, filename, DevUnit);
  341.  
  342.     if (fh = Open(buffer, MODE_NEWFILE)) {
  343.     sprintf(buffer, S_CMDUPDATE "=%d,"
  344.             S_DELAY "=%d,"
  345.             S_SAFEWRITE "=%d,"
  346.             S_MaxCache "=%d,"
  347.             S_CacheTimeout "=%d,"
  348.             S_XPKPackMethod "=%s,"
  349.             S_LICENSED "=%d",
  350.         Settings.CacheCMDUPDATE,
  351.         Settings.CacheDELAY,
  352.         Settings.CacheSAFE,
  353.         Settings.MaxCache,
  354.         Settings.CacheTimeout,
  355.         Settings.XPKPackMethod,
  356.         Settings.Licensed);
  357.     Write(fh, buffer, strlen(buffer));
  358.     Close(fh);
  359.  
  360.     if (notify && Unit) {
  361.         IOReq->iotd_Req.io_Command = CMD_RESET;
  362.         DoIO((struct IORequest *)IOReq);
  363.     }
  364.     return 1;
  365.     }
  366.  
  367.     Confirm("Error writing \"%s\"", OkString, buffer);
  368.     return 0;
  369. }
  370.  
  371. void
  372. DoSaveAs(void)
  373. {
  374.     struct FileRequester *fr;
  375.  
  376.     if (FileRequest == NULL) {
  377.     FileRequest = (struct FileRequester *)
  378.               AllocAslRequest(ASL_FileRequest, NULL);
  379.     }
  380.  
  381.     if (fr = FileRequest) {
  382.     unsigned char    buffer[256];
  383.  
  384.     if (AslRequestTags(fr,
  385.                 ASL_Hail, "Save settings as",
  386.                 ASL_OKText, "Save",
  387.                 ASL_FuncFlags, FILF_SAVE,
  388.                 TAG_DONE
  389.               ) == 0) {
  390.         goto end;
  391.     }
  392.     strncpy(buffer, fr->rf_Dir, sizeof (buffer) - 1);
  393.     AddPart(buffer, fr->rf_File, sizeof (buffer) - 1);
  394.  
  395.     Save(buffer, 0);
  396.     end:
  397.     }
  398. }
  399.  
  400. void
  401. DoOpen(int ask)
  402. {
  403.     struct FileRequester *fr;
  404.     static        int Ask;
  405.  
  406.     if (FileRequest == NULL) {
  407.     FileRequest = (struct FileRequester *)
  408.               AllocAslRequest(ASL_FileRequest, NULL);
  409.     ask = 1;
  410.     }
  411.  
  412.     ask |= Ask;
  413.  
  414.     if (fr = FileRequest) {
  415.     unsigned char    buffer[256];
  416.     UNIT        unit;
  417.  
  418.     if (ask &&
  419.         AslRequestTags(fr,
  420.                 ASL_Hail, "Load settings",
  421.                 ASL_OKText, "Load",
  422.                 ASL_FuncFlags, 0,
  423.                 TAG_DONE
  424.               ) == 0) {
  425.         Ask = 1;
  426.         goto end;
  427.     }
  428.     strncpy(buffer, fr->rf_Dir, sizeof (buffer) - 1);
  429.     AddPart(buffer, fr->rf_File, sizeof (buffer) - 1);
  430.     Ask = 0;
  431.  
  432.     memset(&unit, 0, sizeof(unit));
  433.     /*
  434.      * I admit, this is roundabout, but saves duplicating the
  435.      * parsing function by using the same code as the device.
  436.      */
  437.     ReadConfig(&unit, buffer, sizeof(buffer));
  438.     ConfigFromUnit(&unit);
  439.     end: ;
  440.     }
  441. }
  442.  
  443. int
  444. DoAbout(void)
  445. {
  446.     struct EasyStruct er = {
  447.     sizeof er, 0, "About...",
  448. "xpkdisk.device \xA9 1993 by Olaf Seibert.\n"
  449. "\n"
  450. "  This program is distributed in the hope that it will be useful,\n"
  451. "  but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  452. "  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
  453. "\n"
  454. "See documentation and GNU General Public License for distribution.",
  455.             "Accept License|Reject License"
  456.     };
  457.  
  458.     if (EasyRequestArgs(PrefsWnd, &er, NULL, NULL) == 0) {
  459.     return DONE_DONE;
  460.     }
  461.     Settings.Licensed = 1;
  462.     return 0;
  463. }
  464.  
  465. void
  466. MaybeAbout(void)
  467. {
  468.     if (!Settings.Licensed && DoAbout())
  469.     Die();
  470. }
  471.  
  472. int
  473. DoGadget(struct IntuiMessage *imsg)
  474. {
  475.     struct Gadget  *gd;
  476.     int         id;
  477.  
  478.     gd = (struct Gadget *) imsg->IAddress;
  479.     if (gd == NULL)
  480.     return 0;
  481.     id = gd->GadgetID;
  482.  
  483.     switch (id) {
  484.     case GD_UNIT:
  485.     SelectUnit(imsg->Code);
  486.     break;
  487.     case GD_MAXCACHE:
  488.     Settings.MaxCache = imsg->Code;
  489.     break;
  490.     case GD_CMDUPDATE:
  491.     Settings.CacheCMDUPDATE = (gd->Flags & GFLG_SELECTED) != 0;
  492.     break;
  493.     case GD_DELAY:
  494.     Settings.CacheDELAY = (gd->Flags & GFLG_SELECTED) != 0;
  495.     break;
  496.     case GD_SAFE:
  497.     Settings.CacheSAFE = (gd->Flags & GFLG_SELECTED) != 0;
  498.     break;
  499.     case GD_TIME:
  500.     Settings.CacheTimeout = imsg->Code;
  501.     break;
  502.     case GD_METHOD:
  503.     strncpy(Settings.XPKPackMethod, GetString(gd), 9);
  504.     break;
  505.     case GD_SAVE:
  506.     Save(EnvArc, FALSE);
  507.     /* fall through: SAVE implies USE. */
  508.     case GD_USE:
  509.     Save(Env, TRUE);
  510.     break;
  511.     case GD_QUIT:
  512.     return DONE_DONE;
  513.     }
  514.  
  515.     return 0;
  516. }
  517.  
  518. int
  519. DoMenu(struct IntuiMessage *imsg)
  520. {
  521.     int         menu = MENUNUM(imsg->Code);
  522.     int         item = ITEMNUM(imsg->Code);
  523.  
  524.     switch (menu) {
  525.     case 0:        /* Project */
  526.     switch (item) {
  527.     case 0:     /* - About... */
  528.         return DoAbout();
  529.     case 1:     /* - Open... */
  530.         DoOpen(1);
  531.         break;
  532.     case 2:     /* - Save */
  533.         Save(EnvArc, FALSE);
  534.         goto use;
  535.     case 3:     /* - Save As... */
  536.         DoSaveAs();
  537.         break;
  538.     case 4:     /* - Use */
  539.     use:
  540.         Save(Env, TRUE);
  541.         break;
  542.     case 6:     /* - Quit */
  543.         return DONE_DONE;
  544.     }
  545.     break;
  546.     case 1:        /* Edit */
  547.     switch (item) {
  548.     case 0:     /* - Reset to defaults */
  549.         Settings = Defaults;
  550.         UpdateGadgets();
  551.         break;
  552.     case 1:     /* - Last saved */
  553.         DoOpen(0);
  554.         break;
  555.     case 2:     /* - Restore */
  556.         Settings = Initial;
  557.         UpdateGadgets();
  558.         break;
  559.     }
  560.     break;
  561.     }
  562.     return 0;
  563. }
  564.  
  565. void
  566. MainLoop(void)
  567. {
  568.     long        waitmask;
  569.     long        mainmask;
  570.     long        mask;
  571.     int         done;
  572.  
  573.     done = 0;
  574.  
  575.     if (PrefsWnd)
  576.     mainmask = 1L << PrefsWnd->UserPort->mp_SigBit;
  577.     else
  578.     mainmask = 0;
  579.  
  580.     waitmask = mainmask | SIGBREAKF_CTRL_C;
  581.  
  582.     while (!done) {
  583.     mask = Wait(waitmask);
  584.     if (mask & SIGBREAKF_CTRL_C) {
  585.         done = DONE_DONE;
  586.         break;
  587.     }
  588.     if (mask & mainmask) {
  589.         struct IntuiMessage *imsg;
  590.  
  591.         while (imsg = GT_GetIMsg(PrefsWnd->UserPort)) {
  592.         switch (imsg->Class) {
  593.         case IDCMP_CLOSEWINDOW:
  594.             done = DONE_DONE;
  595.             break;
  596.         case IDCMP_GADGETDOWN:
  597.         case IDCMP_GADGETUP:
  598.         case IDCMP_MOUSEMOVE:
  599.             done = DoGadget(imsg);
  600.             break;
  601.         case IDCMP_MENUPICK:
  602.             done = DoMenu(imsg);
  603.             break;
  604.         case IDCMP_REFRESHWINDOW:
  605.             GT_BeginRefresh(imsg->IDCMPWindow);
  606.             PrefsRender();
  607.             GT_EndRefresh(imsg->IDCMPWindow, TRUE);
  608.             break;
  609.         }
  610.         GT_ReplyIMsg(imsg);
  611.         }
  612.     }
  613.     }
  614. }
  615.  
  616. void chkabort(void) {}      /* DICE specific. */
  617.  
  618. int
  619. main(int argc, char **argv)
  620. {
  621.     OpenAll(argc, argv);
  622.     MaybeAbout();
  623.     MainLoop();
  624.     Die();
  625.  
  626.     return 0;
  627. }
  628.  
  629. #ifndef WORKBENCH_STARTUP_H
  630. #include <workbench/startup.h>
  631. #endif
  632.  
  633. int
  634. wbmain(struct WBStartup *wbs)
  635. {
  636.     int         rc;
  637.     long        lock;
  638.  
  639.     if (wbs->sm_ArgList)
  640.     lock = CurrentDir(wbs->sm_ArgList->wa_Lock);
  641.     rc = main(0, (char **)wbs);
  642.     if (wbs->sm_ArgList)
  643.     CurrentDir(lock);
  644.     return rc;
  645. }
  646.